home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 201-225 / disk_220 / dnet / lib / dnetlib.c next >
Encoding:
C/C++ Source or Header  |  1992-05-06  |  6.0 KB  |  362 lines
  1.  
  2. /*
  3.  *  DNETLIB.C
  4.  *
  5.  *    DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  Library Interface for DNET.
  8.  */
  9.  
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <fcntl.h>
  13. #include <signal.h>
  14. #include <stdio.h>
  15. #include <errno.h>
  16. #ifdef O_CREAT
  17. #include <sys/file.h>
  18. #endif
  19. #include "../lib/dnetlib.h"
  20.  
  21. extern char *getenv();
  22.  
  23. typedef unsigned short uword;
  24. typedef unsigned long ulong;
  25. typedef unsigned char ubyte;
  26. typedef struct sockaddr SOCKADDR;
  27.  
  28. typedef struct {
  29.     int s;
  30.     uword port;
  31. } CHANN;
  32.  
  33. #define NAMELEN sizeof(".PORT.XXXXX")
  34. #define NAMEPAT "%s.PORT.%ld"
  35.  
  36. char *getdirpart();
  37.  
  38. CHANN *
  39. DListen(port)
  40. uword port;
  41. {
  42.     CHANN *chan;
  43.     int s;
  44.     SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
  45.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  46.  
  47.     sprintf(sa->sa_data, NAMEPAT, dirstr, port);
  48.     sa->sa_family = AF_UNIX;
  49.     unlink(sa->sa_data);
  50.  
  51.     s = socket(PF_UNIX, SOCK_STREAM, 0);
  52.     fcntl(s, F_SETOWN, getpid());
  53.     if (bind(s, sa, sizeof(*sa)-sizeof(sa->sa_data)+strlen(sa->sa_data)) < 0) {
  54.     close(s);
  55.     free(sa);
  56.     return(NULL);
  57.     }
  58.     if (listen(s, 5) < 0) {
  59.     close(s);
  60.     unlink(sa->sa_data);
  61.     free(sa);
  62.     return(NULL);
  63.     }
  64.     chan = (CHANN *)malloc(sizeof(CHANN));
  65.     chan->s = s;
  66.     chan->port = port;
  67.     free(sa);
  68.     return(chan);
  69. }
  70.  
  71.  
  72. DUnListen(chan)
  73. CHANN *chan;
  74. {
  75.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  76.     char buf[32];
  77.  
  78.     close(chan->s);
  79.     sprintf(buf, NAMEPAT, dirstr, chan->port);
  80.     unlink(buf);
  81.     free(chan);
  82. }
  83.  
  84. DAccept(chan)
  85. CHANN *chan;
  86. {
  87.     SOCKADDR sa;
  88.     int addrlen = sizeof(sa);
  89.     int fd;
  90.  
  91.     fd = accept(chan->s, &sa, &addrlen);
  92.     return(fd);
  93. }
  94.  
  95. DOpen(host, port, txpri, rxpri)
  96. char *host;
  97. uword port;
  98. char txpri, rxpri;
  99. {
  100.     int s;
  101.     char rc;
  102.     short xb[3];
  103.     SOCKADDR *sa = (SOCKADDR *)malloc(sizeof(SOCKADDR)+256);
  104.     char *dirstr = getenv("DNETDIR") ? getenv("DNETDIR") : "";
  105.  
  106.     if (rxpri < -127)
  107.     rxpri = -127;
  108.     if (rxpri > 126)
  109.     rxpri = 126;
  110.     if (txpri < -127)
  111.     txpri = -127;
  112.     if (txpri > 126)
  113.     txpri = 126;
  114.  
  115.     if (host == NULL)
  116.     host = (getenv("DNETHOST")) ? getenv("DNETHOST"):"";
  117.  
  118.     sa->sa_family = AF_INET;
  119.     sprintf(sa->sa_data, "%s%s%s", dirstr, "DNET.", host);
  120.  
  121.     s = socket(PF_UNIX, SOCK_STREAM, 0);
  122.     fcntl(s, F_SETOWN, getpid());
  123.     if (connect(s, sa, sizeof(*sa)-sizeof(sa->sa_data)+
  124.     strlen(sa->sa_data))<0) {
  125.     close(s);
  126.     free(sa);
  127.     return(-1);
  128.     }
  129.     free(sa);
  130.     xb[0] = port;
  131.     ((char *)&xb[1])[0] = txpri;
  132.     ((char *)&xb[1])[1] = rxpri;
  133.     write(s, xb, 4);
  134.     if (read(s, &rc, 1) == 1 && rc == 0)
  135.     return(s);
  136.     close(s);
  137.     return(-1);
  138. }
  139.  
  140. DEof(fd)
  141. {
  142.     char dummy;
  143.  
  144.     shutdown(fd, 1);
  145.     write(fd, &dummy, 0);
  146. }
  147.  
  148. gwrite(fd, buf, bytes)
  149. char *buf;
  150. {
  151.     int n;
  152.     int orig = bytes;
  153.     extern int errno;
  154.     while (bytes) {
  155.     n = write(fd, buf, bytes);
  156.     if (n > 0) {
  157.         bytes -= n;
  158.         buf += n;
  159.         continue;
  160.     }
  161.     if (n < 0) {
  162.         if (errno == EINTR)
  163.         continue;
  164.         if (errno == EWOULDBLOCK) {
  165.         int wm = 1 << fd;
  166.         int em = 1 << fd;
  167.         if (select(fd+1, NULL, &wm, &em, NULL) < 0)
  168.             continue;
  169.         if (wm)
  170.             continue;
  171.         }
  172.         return(orig - bytes);
  173.     }
  174.     }
  175.     return(orig);
  176. }
  177.  
  178. gread(fd, buf, bytes)
  179. char *buf;
  180. {
  181.     int n;
  182.     int orig = bytes;
  183.     extern int errno;
  184.     while (bytes) {
  185.     n = read(fd, buf, bytes);
  186.     if (n > 0) {
  187.         bytes -= n;
  188.         buf += n;
  189.         break;
  190.     }
  191.     if (n < 0) {
  192.         if (errno == EINTR)
  193.         continue;
  194.         if (errno == EWOULDBLOCK) {
  195.         int rm = 1 << fd;
  196.         int em = 1 << fd;
  197.         if (select(fd+1, &rm, NULL, &em, NULL) < 0)
  198.             continue;
  199.         if (rm)
  200.             continue;
  201.         }
  202.         return(orig - bytes);
  203.     }
  204.     if (n == 0)
  205.         break;
  206.     }
  207.     return(orig - bytes);
  208. }
  209.  
  210. ggread(fd, buf, bytes)
  211. char *buf;
  212. {
  213.     int n;
  214.     int ttl = 0;
  215.     while (bytes) {
  216.     n = gread(fd, buf, bytes);
  217.     if (n > 0) {
  218.         bytes -= n;
  219.         buf += n;
  220.         ttl += n;
  221.         continue;
  222.     }
  223.     return(-1);
  224.     }
  225.     return(ttl);
  226. }
  227.  
  228. /*
  229.  *    Convert to and from 68000 longword format.  Of course, it really
  230.  *    doesn't matter what format you use, just as long as it is defined.
  231.  */
  232.  
  233. ntohl68(n)
  234. ulong n;
  235. {
  236.     return(
  237.     (((ubyte *)&n)[0] << 24)|
  238.     (((ubyte *)&n)[1] << 16)|
  239.     (((ubyte *)&n)[2] << 8)|
  240.     (((ubyte *)&n)[3])
  241.     );
  242. }
  243.  
  244. htonl68(n)
  245. ulong n;
  246. {
  247.     ulong v;
  248.     ((ubyte *)&v)[0] = n >> 24;
  249.     ((ubyte *)&v)[1] = n >> 16;
  250.     ((ubyte *)&v)[2] = n >> 8;
  251.     ((ubyte *)&v)[3] = n;
  252.     return(v);
  253. }
  254.  
  255.  
  256. DoOption(ac, av, ops, args)
  257. short ac;
  258. char *av[];
  259. char *ops;
  260. long args;
  261. {
  262.     register short i;
  263.     short j;
  264.  
  265.     for (i = j = 1; i < ac; ++i) {
  266.     register char *ptr = av[i];
  267.     if (*ptr != '-') {
  268.         av[j++] = av[i];
  269.         continue;
  270.     }
  271.     while (*++ptr) {
  272.         register char *op;
  273.         long **ap = (long **)&args;
  274.         short isshort;
  275.  
  276.         for (op = ops; *op && *op != *ptr;) {
  277.         if (*op == *ptr)
  278.             break;
  279.         if (*++op == '%') {
  280.             while (*op && *op != 's' && *op != 'd')
  281.             ++op;
  282.             if (*op)
  283.             ++op;
  284.         }
  285.         if (*op == ',')     /*  optional ,  */
  286.             ++op;
  287.         ++ap;
  288.         }
  289.         if (*op == 0)
  290.         return(-1);
  291.         if (op[1] != '%') {
  292.         *(short *)*ap = 1;
  293.         ++ap;
  294.         continue;
  295.         }
  296.         op += 2;
  297.         isshort = 1;
  298.         while (*op && *op != 's' && *op != 'd') {
  299.         switch(*op) {
  300.         case 'h':
  301.             isshort = 1;
  302.             break;
  303.         case 'l':
  304.             isshort = 0;
  305.             break;
  306.         default:
  307.             return(-1);
  308.         }
  309.         ++op;
  310.         }
  311.         switch(*op) {
  312.         case 's':
  313.         if (ptr[1]) {
  314.             *(char **)*ap = ptr + 1;
  315.             ptr = "\0";
  316.         } else {
  317.             *(char **)*ap = av[++i];
  318.         }
  319.         break;
  320.         case 'd':
  321.         if (isshort)
  322.             *(short *)*ap = atoi(++ptr);
  323.         else
  324.             *(long *)*ap = atoi(++ptr);
  325.         while (*ptr >= '0' && *ptr <= '9')
  326.             ++ptr;
  327.         break;
  328.         default:
  329.         return(-1);
  330.         }
  331.     }
  332.     }
  333.     return(j);
  334. }
  335.  
  336. elog(how, ctl, arg)
  337. char *ctl;
  338. long arg;
  339. {
  340.     char *dir = getenv("DNETDIR");
  341.     FILE *fi;
  342.     char buf[256];
  343.     long dtime;
  344.  
  345.     time(&dtime);
  346.  
  347.     if (!dir)
  348.     dir = "";
  349.     sprintf(buf, "%s%s", dir, "DNET.LOG");
  350.     if (fi = fopen(buf, "a")) {
  351.     strcpy(buf, ctime(&dtime));
  352.     buf[strlen(buf)-1] = 0;
  353.     fprintf(fi, "%s ", buf);
  354.     fprintf(fi, ctl, arg);
  355.     putc('\n', fi);
  356.     fclose(fi);
  357.     }
  358.     if (how == EFATAL)
  359.     exit(1);
  360. }
  361.  
  362.